package com.gewu.pm.ui.activity.filter.manager;

import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.TextView;

import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import com.gewu.pm.R;
import com.gewu.pm.app.AppActivity;
import com.gewu.pm.ui.activity.filter.config.FilterConfig;
import com.gewu.pm.ui.activity.filter.config.FilterItem;
import com.gewu.pm.ui.activity.filter.config.SelectorType;
import com.gewu.pm.ui.adapter.FilterOrderStatusAdapter;
import com.gewu.pm.ui.adapter.FilterTagAdapter;
import com.gewu.pm.ui.adapter.FilterTimeAdapter;
import com.gewu.pm.ui.dialog.DateDialog;
import com.gewu.pm.ui.dialog.SelectHandlingPersonDialog;
import com.gewu.pm.ui.dialog.SelectSalesRegionDialog;
import com.gewu.pm.ui.dialog.SelectSalespersonDialog;
import com.gewu.pm.ui.dialog.SelectSubmitterDialog;
import com.gewu.pm.ui.dialog.SelectionListDialog;
import com.gewu.pm.ui.dialog.bean.SalespersonBean;
import com.gewu.pm.utils.MoneyInputHelper;
import com.hjq.base.BaseAdapter;
import com.hjq.base.BaseDialog;

import java.util.HashMap;
import java.util.Map;

/**
 * 筛选管理器（核心类）
 * 
 * 职责：
 * 1. 根据FilterConfig动态生成筛选UI
 * 2. 管理筛选数据的存储和获取
 * 3. 处理各种筛选控件的交互逻辑
 * 4. 提供重置和收集数据的功能
 * 
 * 设计模式：
 * - 组合模式：被BaseFilterActivity组合使用，实现"组合优于继承"
 * - 策略模式：根据FilterType执行不同的UI生成策略
 * - 工厂方法模式：提供多个工厂方法创建不同类型的筛选控件
 * 
 * 核心方法：
 * - init(FilterConfig)：初始化筛选器，生成UI
 * - collectData()：收集所有筛选数据
 * - reset()：重置所有筛选条件
 * 
 * 使用示例：
 * <pre>
 * FilterManager manager = new FilterManager(activity, container);
 * manager.init(config);
 * Map<String, Object> data = manager.collectData();
 * </pre>
 * 
 * @author AI Assistant
 * @since 1.0
 */
public final class FilterManager implements BaseAdapter.OnItemClickListener {
    
    /** Activity上下文，用于显示对话框和获取资源 */
    private final AppActivity mActivity;
    
    /** 筛选控件的容器，所有动态生成的View都添加到这里 */
    private final LinearLayout mContainer;
    
    /** 布局填充器，用于加载XML布局文件 */
    private final LayoutInflater mInflater;
    
    /** 筛选配置，包含所有筛选项的定义 */
    private FilterConfig mConfig;
    
    /** 
     * 筛选数据存储
     * key: 筛选项的唯一标识（如"sales_area"、"submit_time"）
     * value: 筛选值（String、List<String>等）
     */
    private final Map<String, Object> mFilterData = new HashMap<>();
    
    /** 
     * View映射表
     * key: 筛选项的唯一标识
     * value: 对应的View控件（TextView、EditText、RecyclerView等）
     * 用途：重置时清空控件、收集数据时获取控件值
     */
    private final Map<String, View> mViewMap = new HashMap<>();
    
    /** 
     * Adapter映射表
     * key: 筛选项的唯一标识
     * value: 对应的RecyclerView.Adapter
     * 用途：重置时清空选中状态、收集数据时获取选中项
     */
    private final Map<String, BaseAdapter<?>> mAdapterMap = new HashMap<>();
    
    /**
     * 构造方法
     * 
     * @param activity Activity上下文，必须是AppActivity或其子类
     * @param container 筛选控件的容器，通常是一个LinearLayout
     */
    public FilterManager(AppActivity activity, LinearLayout container) {
        this.mActivity = activity;
        this.mContainer = container;
        this.mInflater = LayoutInflater.from(activity);
    }
    
    /**
     * 初始化筛选器
     * 
     * 功能：
     * 1. 保存筛选配置
     * 2. 根据配置动态生成UI
     * 3. 清空之前的筛选数据
     * 
     * 调用时机：
     * - BaseFilterActivity的initData()方法中调用
     * - 只调用一次
     * 
     * @param config 筛选配置，包含所有筛选项的定义
     */
    public void init(FilterConfig config) {
        this.mConfig = config;
        generateUI();
    }
    
    /**
     * 动态生成UI（核心方法）
     * 
     * 流程：
     * 1. 清空容器中的所有旧View
     * 2. 遍历配置中的所有筛选项
     * 3. 根据筛选项类型（FilterType）调用对应的工厂方法
     * 4. 将生成的View添加到容器中
     * 
     * 策略模式应用：
     * - 根据FilterType执行不同的UI生成策略
     * - 每种类型对应一个工厂方法（addXxxSelector）
     * 
     * 支持的筛选类型：
     * - TEXT_SELECTOR：文本选择器（点击弹出对话框选择）
     * - TAG_SELECTOR：单选标签（如：今天、本周、本月）
     * - MULTI_TAG_SELECTOR：多选标签（如：已完成、拜访中、已取消）
     * - TIME_SELECTOR：时间选择器（预设时间段）
     * - DATE_RANGE_SELECTOR：日期范围选择器（开始日期-结束日期）
     * - AMOUNT_RANGE_SELECTOR：金额范围选择器（最小金额-最大金额）
     */
    private void generateUI() {
        // 清空容器，移除所有旧的筛选控件
        mContainer.removeAllViews();
        
        // 遍历配置中的所有筛选项
        for (FilterItem item : mConfig.getItems()) {
            // 根据类型调用对应的工厂方法
            switch (item.getType()) {
                case TEXT_SELECTOR:
                    // 文本选择器：销售区域、业务员、配送商等
                    addTextSelector(item);
                    break;
                case TAG_SELECTOR:
                    // 单选标签：拜访类型、申请类型等
                    addTagSelector(item, false);
                    break;
                case MULTI_TAG_SELECTOR:
                    // 多选标签：拜访状态、申请状态等
                    addTagSelector(item, true);
                    break;
                case TIME_SELECTOR:
                    // 时间选择器：今天、本周、本月、本年等
                    addTimeSelector(item);
                    break;
                case DATE_RANGE_SELECTOR:
                    // 日期范围：开始日期-结束日期
                    addDateRangeSelector(item);
                    break;
                case AMOUNT_RANGE_SELECTOR:
                    // 金额范围：最小金额-最大金额
                    addAmountRangeSelector(item);
                    break;
            }
        }
    }
    
    /**
     * 添加文本选择器（工厂方法）
     * 
     * UI结构：
     * - 标题TextView（如："销售区域"）
     * - 选择框TextView（显示选中的值或提示文字）
     * 
     * 交互逻辑：
     * - 点击选择框弹出对话框
     * - 根据SelectorType显示不同的对话框
     * - 选择后更新TextView显示和mFilterData数据
     * 
     * 支持的选择器类型（SelectorType）：
     * - SALES_REGION：销售区域选择
     * - HANDLER：经办人选择
     * - SUBMITTER：提交人选择
     * - SALESPERSON：业务员选择
     * - DISTRIBUTOR：配送商选择
     * - TERMINAL：终端选择
     * - DEPARTMENT：部门选择
     * - CUSTOM_LIST：自定义列表选择
     * 
     * @param item 筛选项配置
     */
    private void addTextSelector(FilterItem item) {
        // 添加标题
        TextView tvLabel = (TextView) mInflater.inflate(R.layout.filter_label_item, mContainer, false);
        tvLabel.setText(item.getLabel());
        mContainer.addView(tvLabel);
        
        // 添加选择框
        TextView tvSelector = (TextView) mInflater.inflate(R.layout.filter_text_selector_item, mContainer, false);
        tvSelector.setText(item.getHint());
        tvSelector.setOnClickListener(v -> handleTextSelectorClick(item, tvSelector));
        mContainer.addView(tvSelector);
        
        mViewMap.put(item.getKey(), tvSelector);
    }
    
    /**
     * 添加标签选择器（工厂方法）
     * 
     * UI结构：
     * - 标题TextView（如："拜访状态"）
     * - RecyclerView（网格布局显示标签）
     * 
     * 交互逻辑：
     * - 单选模式：点击标签选中，再次点击取消选中，只能选一个
     * - 多选模式：点击标签选中/取消，可以选多个
     * - 选中的标签会改变背景色和文字颜色
     * 
     * Adapter类型：
     * - 单选：FilterTagAdapter
     * - 多选：FilterOrderStatusAdapter
     * 
     * 数据存储：
     * - 单选：存储选中的单个字符串
     * - 多选：存储选中的字符串列表，用逗号分隔
     * 
     * @param item 筛选项配置
     * @param isMulti true-多选模式，false-单选模式
     */
    private void addTagSelector(FilterItem item, boolean isMulti) {
        // 添加标题
        TextView tvLabel = (TextView) mInflater.inflate(R.layout.filter_label_item, mContainer, false);
        tvLabel.setText(item.getLabel());
        mContainer.addView(tvLabel);
        
        // 添加RecyclerView
        RecyclerView recyclerView = (RecyclerView) mInflater.inflate(R.layout.filter_recyclerview_item, mContainer, false);
        GridLayoutManager layoutManager = new GridLayoutManager(mActivity, item.getColumnCount());
        recyclerView.setLayoutManager(layoutManager);
        
        BaseAdapter<?> adapter;
        if (isMulti) {
            adapter = new FilterOrderStatusAdapter(mActivity);
        } else {
            adapter = new FilterTagAdapter(mActivity);
        }
        adapter.setOnItemClickListener(this);
        recyclerView.setAdapter(adapter);
        
        if (adapter instanceof FilterTagAdapter) {
            ((FilterTagAdapter) adapter).setData(item.getOptions());
        } else if (adapter instanceof FilterOrderStatusAdapter) {
            ((FilterOrderStatusAdapter) adapter).setData(item.getOptions());
        }
        
        mContainer.addView(recyclerView);
        mViewMap.put(item.getKey(), recyclerView);
        mAdapterMap.put(item.getKey(), adapter);
    }
    
    /**
     * 添加时间选择器（工厂方法）
     * 
     * UI结构：
     * - 标题TextView（如："提交时间"）
     * - RecyclerView（网格布局显示时间选项）
     * 
     * 预设时间选项：
     * - 今天、本周、本月、本年等
     * - 选项数量由item.getColumnCount()决定
     * 
     * 交互逻辑：
     * - 单选模式
     * - 点击时间选项选中，再次点击取消选中
     * - 选中后会自动计算对应的日期范围
     * 
     * Adapter类型：
     * - FilterTimeAdapter
     * 
     * 数据存储：
     * - 存储选中的时间选项文本（如："本周"）
     * 
     * @param item 筛选项配置
     */
    private void addTimeSelector(FilterItem item) {
        // 添加标题
        TextView tvLabel = (TextView) mInflater.inflate(R.layout.filter_label_item, mContainer, false);
        tvLabel.setText(item.getLabel());
        mContainer.addView(tvLabel);
        
        // 添加RecyclerView
        RecyclerView recyclerView = (RecyclerView) mInflater.inflate(R.layout.filter_recyclerview_item, mContainer, false);
        GridLayoutManager layoutManager = new GridLayoutManager(mActivity, item.getColumnCount());
        recyclerView.setLayoutManager(layoutManager);
        
        FilterTimeAdapter adapter = new FilterTimeAdapter(mActivity);
        adapter.setOnItemClickListener(this);
        recyclerView.setAdapter(adapter);
        adapter.setData(item.getOptions());
        
        mContainer.addView(recyclerView);
        mViewMap.put(item.getKey(), recyclerView);
        mAdapterMap.put(item.getKey(), adapter);
    }
    
    /**
     * 添加日期范围选择器（工厂方法）
     * 
     * UI结构：
     * - 开始时间选择区域（LinearLayout + TextView）
     * - 结束时间选择区域（LinearLayout + TextView）
     * 
     * 交互逻辑：
     * - 点击开始时间区域弹出日期选择对话框
     * - 点击结束时间区域弹出日期选择对话框
     * - 选择后更新TextView显示
     * 
     * 数据存储：
     * - key + "_start"：开始日期（如："2025-11-10"）
     * - key + "_end"：结束日期（如："2025-11-17"）
     * 
     * 日期格式：
     * - yyyy-MM-dd（如：2025-11-10）
     * 
     * @param item 筛选项配置
     */
    private void addDateRangeSelector(FilterItem item) {
        View dateRangeView = mInflater.inflate(R.layout.filter_date_range_item, mContainer, false);
        
        LinearLayout llStartTime = dateRangeView.findViewById(R.id.ll_start_time);
        TextView tvStartTime = dateRangeView.findViewById(R.id.tv_start_time);
        LinearLayout llEndTime = dateRangeView.findViewById(R.id.ll_end_time);
        TextView tvEndTime = dateRangeView.findViewById(R.id.tv_end_time);
        
        llStartTime.setOnClickListener(v -> showDatePicker(tvStartTime));
        llEndTime.setOnClickListener(v -> showDatePicker(tvEndTime));
        
        mContainer.addView(dateRangeView);
        mViewMap.put(item.getKey() + "_start", tvStartTime);
        mViewMap.put(item.getKey() + "_end", tvEndTime);
    }
    
    /**
     * 添加金额范围选择器（工厂方法）
     * 
     * UI结构：
     * - 标题TextView（如："收款金额"）
     * - 金额范围输入区域（最小金额EditText + 最大金额EditText）
     * 
     * 输入限制：
     * - 只能输入数字和小数点
     * - 自动格式化为金额格式（保留2位小数）
     * - 使用MoneyInputHelper处理输入
     * 
     * 数据存储：
     * - key + "_min"：最小金额（如："100.00"）
     * - key + "_max"：最大金额（如："1000.00"）
     * 
     * 金额格式：
     * - 保留2位小数（如：100.00）
     * 
     * @param item 筛选项配置
     */
    private void addAmountRangeSelector(FilterItem item) {
        // 添加标题
        TextView tvLabel = (TextView) mInflater.inflate(R.layout.filter_label_item, mContainer, false);
        tvLabel.setText(item.getLabel());
        mContainer.addView(tvLabel);
        
        // 添加金额范围输入框
        View amountRangeView = mInflater.inflate(R.layout.filter_amount_range_item, mContainer, false);
        EditText etMinAmount = amountRangeView.findViewById(R.id.et_min_amount);
        EditText etMaxAmount = amountRangeView.findViewById(R.id.et_max_amount);
        
        MoneyInputHelper.setMoneyInput(etMinAmount);
        MoneyInputHelper.setMoneyInput(etMaxAmount);
        
        mContainer.addView(amountRangeView);
        mViewMap.put(item.getKey() + "_min", etMinAmount);
        mViewMap.put(item.getKey() + "_max", etMaxAmount);
    }
    
    /**
     * 处理文本选择器点击事件
     * 
     * 功能：
     * - 根据SelectorType显示对应的选择对话框
     * - 不同的选择器类型对应不同的对话框
     * 
     * 对话框类型映射：
     * - SALES_REGION → SelectSalesRegionDialog（销售区域选择）
     * - HANDLER → SelectHandlingPersonDialog（经办人选择）
     * - SUBMITTER → SelectSubmitterDialog（提交人选择，type=1）
     * - SALESPERSON → SelectSalespersonDialog（业务员选择）
     * - DISTRIBUTOR → SelectSubmitterDialog（配送商选择，type=101）
     * - TERMINAL → SelectSubmitterDialog（终端选择，type=102）
     * - DEPARTMENT → SelectSubmitterDialog（部门选择，type=104）
     * - CUSTOM_LIST → SelectionListDialog（自定义列表选择）
     * - DATE_PICKER → DateDialog（日期选择）
     * 
     * @param item 筛选项配置
     * @param textView 显示选中值的TextView
     */
    private void handleTextSelectorClick(FilterItem item, TextView textView) {
        SelectorType selectorType = item.getSelectorType();
        
        switch (selectorType) {
            case SALES_REGION://销售区域选择器
                showSalesRegionDialog(item, textView);
                break;
            case HANDLER://经办人选择器
                showHandlerDialog(item, textView);
                break;
            case SUBMITTER://提交人选择器
                showSubmitterDialog(item, textView, 1);
                break;
            case SALESPERSON://业务员选择器
                showSalespersonDialog(item, textView);
                break;
            case DISTRIBUTOR://配送商选择器
                showSubmitterDialog(item, textView, 101);
                break;
            case TERMINAL://终端选择器
                showSubmitterDialog(item, textView, 102);
                break;
            case DEPARTMENT://部门选择器
                showSubmitterDialog(item, textView, 104);
                break;
            case CUSTOM_LIST://自定义列表选择器
                showCustomListDialog(item, textView);
                break;
            case DATE_PICKER://日期选择器
                showDatePickerDialog(item, textView);
                break;
        }
    }
    
    /**
     * 处理文本选择器的选择结果
     * 
     * 功能：
     * - 对话框已经处理了单选/多选逻辑
     * - 这里只需要更新显示和样式
     * - 选中后更新边框为红色
     * 
     * @param item 筛选项配置
     * @param textView 显示选中值的TextView
     * @param selectedValue 选中的值（单选为单个值，多选为"、"分隔的字符串）
     */
    private void handleTextSelectorResult(FilterItem item, TextView textView, String selectedValue) {
        // 更新显示文本
        textView.setText(selectedValue);
        
        // 更新文字颜色为红色
        textView.setTextColor(mActivity.getResources().getColor(R.color.red));
        
        // 更新背景为红色边框
        textView.setBackgroundResource(R.drawable.selector_filter_item_selected);
    }
    
    /**
     * 显示销售区域选择对话框
     * 
     * 功能：
     * - 弹出销售区域选择对话框
     * - 支持默认选中（根据textView当前文本）
     * - 选择后更新textView显示和颜色
     * 
     * @param textView 显示选中值的TextView
     */
    private void showSalesRegionDialog(FilterItem item, TextView textView) {
        SelectSalesRegionDialog.Builder builder = new SelectSalesRegionDialog.Builder(mActivity)
                .setMultiSelect(item.isMultiSelect())
                .setListener(new SelectSalesRegionDialog.OnListener() {
                    @Override
                    public void onSelected(BaseDialog dialog, String region) {
                        handleTextSelectorResult(item, textView, region);
                    }
                });
        
        // 设置默认选中
        String currentText = textView.getText().toString();
        if (!currentText.equals(item.getHint())) {
            if (item.isMultiSelect()) {
                builder.setDefaultRegions(currentText);
            } else {
                builder.setDefaultRegion(currentText);
            }
        }
        
        builder.show();
    }
    
    /**
     * 显示经办人选择对话框
     * 
     * 功能：
     * - 弹出经办人选择对话框
     * - 支持默认选中
     * - 选择后更新textView显示和颜色
     * 
     * @param textView 显示选中值的TextView
     */
    private void showHandlerDialog(FilterItem item, TextView textView) {
        SelectHandlingPersonDialog.Builder builder = new SelectHandlingPersonDialog.Builder(mActivity)
                .setMultiSelect(item.isMultiSelect())
                .setListener(new SelectHandlingPersonDialog.OnListener() {
                    @Override
                    public void onSelected(BaseDialog dialog, String personName) {
                        handleTextSelectorResult(item, textView, personName);
                    }
                });
        
        // 设置默认选中
        String currentText = textView.getText().toString();
        if (!currentText.equals(item.getHint())) {
            if (item.isMultiSelect()) {
                builder.setDefaultPersons(currentText);
            } else {
                builder.setDefaultPerson(currentText);
            }
        }
        
        builder.show();
    }
    
    /**
     * 显示提交人/配送商/终端/部门选择对话框
     * 
     * 功能：
     * - 通用的选择对话框，根据type显示不同的数据
     * - 选择后更新textView显示和颜色
     * 
     * type类型：
     * - 1：提交人
     * - 101：配送商
     * - 102：终端
     * - 104：部门
     * 
     * @param textView 显示选中值的TextView
     * @param type 选择器类型
     */
    private void showSubmitterDialog(FilterItem item, TextView textView, int type) {
        new SelectSubmitterDialog.Builder(mActivity, type)
                .setMultiSelect(item.isMultiSelect())
                .setListener(new SelectSubmitterDialog.OnListener() {
                    @Override
                    public void onSelected(BaseDialog dialog, String submitter, int type, Object data) {
                        handleTextSelectorResult(item, textView, submitter);
                    }
                })
                .show();
    }
    
    /**
     * 显示业务员选择对话框
     * 
     * 功能：
     * - 弹出业务员选择对话框
     * - 选择后更新textView显示和颜色
     * - 返回业务员姓名和Bean对象
     * 
     * @param textView 显示选中值的TextView
     */
    private void showSalespersonDialog(FilterItem item, TextView textView) {
        new SelectSalespersonDialog.Builder(mActivity)
                .setMultiSelect(item.isMultiSelect())
                .setListener(new SelectSalespersonDialog.OnListener() {
                    @Override
                    public void onSelected(BaseDialog dialog, String name, SalespersonBean salesperson) {
                        handleTextSelectorResult(item, textView, name);
                    }
                })
                .show();
    }
    
    /**
     * 显示自定义列表选择对话框
     * 
     * 功能：
     * - 弹出通用的列表选择对话框
     * - 数据来源于FilterItem的options
     * - 支持默认选中
     * - 选择后更新textView显示和颜色
     * 
     * 适用场景：
     * - 拜访类型、申请类型等预定义的选项列表
     * 
     * @param textView 显示选中值的TextView
     * @param item 筛选项配置，包含选项列表
     */
    private void showCustomListDialog(FilterItem item, TextView textView) {
        new SelectionListDialog.Builder(mActivity)
                .setTitle(item.getLabel())
                .setDataList(item.getOptions())
                .setMultiSelect(item.isMultiSelect())
                .setDefaultSelection(textView.getText().toString())
                .setListener(new SelectionListDialog.OnListener() {
                    @Override
                    public void onSelected(BaseDialog dialog, String selectedItem, int position) {
                        handleTextSelectorResult(item, textView, selectedItem);
                    }
                })
                .show();
    }
    
    /**
     * 显示日期选择对话框（用于TEXT_SELECTOR类型）
     * 
     * 功能：
     * - 弹出日期选择对话框
     * - 选择后更新textView显示和颜色
     * - 日期格式：yyyy年MM月dd日
     * - 更新边框为红色
     * 
     * 使用场景：
     * - 最近跟进时间等单个日期选择
     * 
     * @param item 筛选项配置
     * @param textView 显示选中日期的TextView
     */
    private void showDatePickerDialog(FilterItem item, TextView textView) {
        new DateDialog.Builder(mActivity)
                .setTitle(item.getLabel())
                .setConfirm(mActivity.getString(R.string.common_confirm))
                .setCancel(mActivity.getString(R.string.common_cancel))
                .setListener(new DateDialog.OnListener() {
                    @Override
                    public void onSelected(BaseDialog dialog, int year, int month, int day) {
                        String time = year + mActivity.getString(R.string.common_year) + 
                                month + mActivity.getString(R.string.common_month) + 
                                day + mActivity.getString(R.string.common_day);
                        handleTextSelectorResult(item, textView, time);
                    }
                })
                .show();
    }
    
    /**
     * 显示日期选择对话框
     * 
     * 功能：
     * - 弹出日期选择对话框
     * - 选择后更新textView显示和颜色
     * - 日期格式：yyyy年MM月dd日
     * 
     * 使用场景：
     * - 日期范围选择器的开始日期和结束日期
     * 
     * @param textView 显示选中日期的TextView
     */
    private void showDatePicker(TextView textView) {
        new DateDialog.Builder(mActivity)
                .setTitle(mActivity.getString(R.string.date_title))
                .setConfirm(mActivity.getString(R.string.common_confirm))
                .setCancel(mActivity.getString(R.string.common_cancel))
                .setListener(new DateDialog.OnListener() {
                    @Override
                    public void onSelected(BaseDialog dialog, int year, int month, int day) {
                        String time = year + mActivity.getString(R.string.common_year) + 
                                month + mActivity.getString(R.string.common_month) + 
                                day + mActivity.getString(R.string.common_day);
                        textView.setText(time);
                        textView.setTextColor(mActivity.getResources().getColor(R.color.cb3));
                    }
                })
                .show();
    }
    
    /**
     * 重置所有筛选项（公共方法）
     * 
     * 功能：
     * 1. 遍历所有筛选项
     * 2. 根据类型执行不同的重置逻辑
     * 3. 清空mFilterData中的所有数据
     * 
     * 重置逻辑：
     * - TEXT_SELECTOR：恢复为提示文字，颜色改为灰色
     * - TAG_SELECTOR/TIME_SELECTOR：清空Adapter的选中状态
     * - MULTI_TAG_SELECTOR：清空多选Adapter的选中状态
     * - DATE_RANGE_SELECTOR：恢复为"开始时间"和"结束时间"，颜色改为灰色
     * - AMOUNT_RANGE_SELECTOR：清空输入框
     * 
     * 调用时机：
     * - 点击重置按钮时
     * - BaseFilterActivity的onClick()方法中调用
     */
    public void reset() {
        for (FilterItem item : mConfig.getItems()) {
            String key = item.getKey();
            
            switch (item.getType()) {
                case TEXT_SELECTOR://文本选择器（点击弹出对话框）
                    TextView textView = (TextView) mViewMap.get(key);
                    if (textView != null) {
                        textView.setText(item.getHint());
                        textView.setTextColor(mActivity.getResources().getColor(R.color.cb9));
                        // 恢复默认背景
                        textView.setBackgroundResource(R.drawable.selector_filter_item_ripple);
                    }
                    break;
                    
                case TAG_SELECTOR://标签选择器（RecyclerView网格，单选）
                case TIME_SELECTOR://时间选择器（RecyclerView网格）
                    BaseAdapter<?> adapter = mAdapterMap.get(key);
                    if (adapter instanceof FilterTagAdapter) {
                        ((FilterTagAdapter) adapter).clearSelection();
                    } else if (adapter instanceof FilterTimeAdapter) {
                        ((FilterTimeAdapter) adapter).clearSelection();
                    }
                    break;
                    
                case MULTI_TAG_SELECTOR://多选标签选择器（RecyclerView网格，多选）
                    BaseAdapter<?> multiAdapter = mAdapterMap.get(key);
                    if (multiAdapter instanceof FilterOrderStatusAdapter) {
                        ((FilterOrderStatusAdapter) multiAdapter).clearSelection();
                    }
                    break;
                    
                case DATE_RANGE_SELECTOR://日期范围选择器（开始时间-结束时间）
                    TextView startTime = (TextView) mViewMap.get(key + "_start");
                    TextView endTime = (TextView) mViewMap.get(key + "_end");
                    if (startTime != null) {
                        startTime.setText(R.string.start_time);
                        startTime.setTextColor(mActivity.getResources().getColor(R.color.cb9));
                    }
                    if (endTime != null) {
                        endTime.setText(R.string.end_time);
                        endTime.setTextColor(mActivity.getResources().getColor(R.color.cb9));
                    }
                    break;
                    
                case AMOUNT_RANGE_SELECTOR://金额范围选择器（最小金额-最大金额）
                    EditText minAmount = (EditText) mViewMap.get(key + "_min");
                    EditText maxAmount = (EditText) mViewMap.get(key + "_max");
                    if (minAmount != null) {
                        minAmount.setText("");
                    }
                    if (maxAmount != null) {
                        maxAmount.setText("");
                    }
                    break;
            }
        }
        
        mFilterData.clear();
    }
    
    /**
     * 收集筛选数据（公共方法）
     * 
     * 功能：
     * 1. 清空mFilterData中的旧数据
     * 2. 遍历所有筛选项
     * 3. 根据类型从对应的View/Adapter中获取数据
     * 4. 只收集非空且非默认值的数据
     * 
     * 收集逻辑：
     * - TEXT_SELECTOR：获取TextView文本，排除提示文字
     * - TAG_SELECTOR/TIME_SELECTOR：从单选Adapter获取选中文本
     * - MULTI_TAG_SELECTOR：从多选Adapter获取选中文本（逗号分隔）
     * - DATE_RANGE_SELECTOR：获取开始和结束日期，排除默认提示
     * - AMOUNT_RANGE_SELECTOR：获取最小和最大金额，排除空值
     * 
     * 返回数据格式：
     * - key：筛选项的唯一标识（如"sales_area"、"submit_time"）
     * - value：筛选值（String类型）
     * 
     * 特殊处理：
     * - 日期范围：key + "_start" 和 key + "_end"
     * - 金额范围：key + "_min" 和 key + "_max"
     * 
     * 调用时机：
     * - 点击确认按钮时
     * - BaseFilterActivity的onClick()方法中调用
     * 
     * @return 筛选数据Map，可能为空（未选择任何筛选条件）
     */
    public Map<String, Object> collectData() {
        mFilterData.clear();
        
        for (FilterItem item : mConfig.getItems()) {
            String key = item.getKey();
            
            switch (item.getType()) {
                case TEXT_SELECTOR:
                    TextView textView = (TextView) mViewMap.get(key);
                    if (textView != null) {
                        String text = textView.getText().toString();
                        if (!text.equals(item.getHint())) {
                            // 多选模式：将"、"替换为","
                            // 单选模式：直接存储
                            if (item.isMultiSelect() && text.contains("、")) {
                                mFilterData.put(key, text.replace("、", ","));
                            } else {
                                mFilterData.put(key, text);
                            }
                        }
                    }
                    break;
                    
                case TAG_SELECTOR:
                case TIME_SELECTOR:
                    BaseAdapter<?> adapter = mAdapterMap.get(key);
                    String selectedText = "";
                    if (adapter instanceof FilterTagAdapter) {
                        selectedText = ((FilterTagAdapter) adapter).getSelectedText();
                    } else if (adapter instanceof FilterTimeAdapter) {
                        selectedText = ((FilterTimeAdapter) adapter).getSelectedText();
                    }
                    if (!TextUtils.isEmpty(selectedText)) {
                        mFilterData.put(key, selectedText);
                    }
                    break;
                    
                case MULTI_TAG_SELECTOR:
                    BaseAdapter<?> multiAdapter = mAdapterMap.get(key);
                    if (multiAdapter instanceof FilterOrderStatusAdapter) {
                        String multiText = ((FilterOrderStatusAdapter) multiAdapter).getSelectedText();
                        if (!TextUtils.isEmpty(multiText)) {
                            mFilterData.put(key, multiText);
                        }
                    }
                    break;
                    
                case DATE_RANGE_SELECTOR:
                    TextView startTime = (TextView) mViewMap.get(key + "_start");
                    TextView endTime = (TextView) mViewMap.get(key + "_end");
                    if (startTime != null && endTime != null) {
                        String start = startTime.getText().toString();
                        String end = endTime.getText().toString();
                        if (!start.equals(mActivity.getString(R.string.start_time))) {
                            mFilterData.put(key + "_start", start);
                        }
                        if (!end.equals(mActivity.getString(R.string.end_time))) {
                            mFilterData.put(key + "_end", end);
                        }
                    }
                    break;
                    
                case AMOUNT_RANGE_SELECTOR:
                    EditText minAmount = (EditText) mViewMap.get(key + "_min");
                    EditText maxAmount = (EditText) mViewMap.get(key + "_max");
                    if (minAmount != null && maxAmount != null) {
                        String min = minAmount.getText().toString().trim();
                        String max = maxAmount.getText().toString().trim();
                        if (!TextUtils.isEmpty(min)) {
                            mFilterData.put(key + "_min", min);
                        }
                        if (!TextUtils.isEmpty(max)) {
                            mFilterData.put(key + "_max", max);
                        }
                    }
                    break;
            }
        }
        
        return mFilterData;
    }
    
    /**
     * RecyclerView Item点击事件回调
     * 
     * 功能：
     * - 处理标签选择器和时间选择器的点击事件
     * - 根据Adapter类型执行不同的选中逻辑
     * 
     * 处理逻辑：
     * - FilterTimeAdapter：设置单选位置（点击选中，再次点击取消）
     * - FilterTagAdapter：设置单选位置（点击选中，再次点击取消）
     * - FilterOrderStatusAdapter：切换选中状态（多选模式）
     * 
     * 实现方式：
     * - 遍历mAdapterMap找到对应的Adapter
     * - 根据Adapter类型调用对应的方法
     * 
     * @param recyclerView 被点击的RecyclerView
     * @param itemView 被点击的Item View
     * @param position 被点击的位置
     */
    @Override
    public void onItemClick(RecyclerView recyclerView, View itemView, int position) {
        // 查找对应的Adapter
        for (Map.Entry<String, BaseAdapter<?>> entry : mAdapterMap.entrySet()) {
            if (recyclerView.getAdapter() == entry.getValue()) {
                BaseAdapter<?> adapter = entry.getValue();
                
                if (adapter instanceof FilterTimeAdapter) {
                    ((FilterTimeAdapter) adapter).setSelectedPosition(position);
                } else if (adapter instanceof FilterTagAdapter) {
                    ((FilterTagAdapter) adapter).setSelectedPosition(position);
                } else if (adapter instanceof FilterOrderStatusAdapter) {
                    ((FilterOrderStatusAdapter) adapter).toggleSelection(position);
                }
                break;
            }
        }
    }
}
